home *** CD-ROM | disk | FTP | other *** search
/ Macwelt 1 / Macwelt DVD 1.toast / Software für Mac-OS X / Entwickler-Tools / netbeans / modules / ext / djava.jar / koala / dynamicjava / interpreter / ClassFactory.class (.txt) next >
Encoding:
Java Class File  |  2000-03-14  |  17.6 KB  |  1,020 lines
  1. package koala.dynamicjava.interpreter;
  2.  
  3. import java.io.ByteArrayOutputStream;
  4. import java.io.DataOutputStream;
  5. import java.io.IOException;
  6. import java.lang.reflect.Modifier;
  7. import koala.dynamicjava.classfile.AttributeOwnerComponent;
  8. import koala.dynamicjava.classfile.BytecodeComponent;
  9. import koala.dynamicjava.classfile.ClassFile;
  10. import koala.dynamicjava.classfile.ClassIdentifier;
  11. import koala.dynamicjava.classfile.CodeAttribute;
  12. import koala.dynamicjava.classfile.ConstantPool;
  13. import koala.dynamicjava.classfile.ConstantString;
  14. import koala.dynamicjava.classfile.ExceptionsAttribute;
  15. import koala.dynamicjava.classfile.FieldInfo;
  16. import koala.dynamicjava.classfile.InnerClassesAttribute;
  17. import koala.dynamicjava.classfile.InnerClassesEntry;
  18. import koala.dynamicjava.classfile.JVMUtilities;
  19. import koala.dynamicjava.classfile.MethodIdentifier;
  20. import koala.dynamicjava.classfile.MethodInfo;
  21.  
  22. public class ClassFactory extends ClassFile {
  23.    private static final String VOID_NAME = JVMUtilities.getName("void");
  24.    private static final String BOOLEAN_NAME = JVMUtilities.getName("boolean");
  25.    private static final String CHAR_NAME = JVMUtilities.getName("char");
  26.    private static final String INT_NAME = JVMUtilities.getName("int");
  27.    private static final String LONG_NAME = JVMUtilities.getName("long");
  28.    private static final String FLOAT_NAME = JVMUtilities.getName("float");
  29.    private static final String DOUBLE_NAME = JVMUtilities.getName("double");
  30.    private static final String BYTE_NAME = JVMUtilities.getName("byte");
  31.    private static final String SHORT_NAME = JVMUtilities.getName("short");
  32.    private static final String OBJECT_NAME = JVMUtilities.getName("java.lang.Object");
  33.    private static final String BOOLEAN_WRAPPER_NAME = JVMUtilities.getName("java.lang.Boolean");
  34.    private static final String CHAR_WRAPPER_NAME = JVMUtilities.getName("java.lang.Character");
  35.    private static final String INT_WRAPPER_NAME = JVMUtilities.getName("java.lang.Integer");
  36.    private static final String LONG_WRAPPER_NAME = JVMUtilities.getName("java.lang.Long");
  37.    private static final String FLOAT_WRAPPER_NAME = JVMUtilities.getName("java.lang.Float");
  38.    private static final String DOUBLE_WRAPPER_NAME = JVMUtilities.getName("java.lang.Double");
  39.    private static final String BYTE_WRAPPER_NAME = JVMUtilities.getName("java.lang.Byte");
  40.    private static final String SHORT_WRAPPER_NAME = JVMUtilities.getName("java.lang.Short");
  41.    private static final String NUMBER_NAME = JVMUtilities.getName("java.lang.Number");
  42.    private static final ClassIdentifier BOOLEAN_IDENTIFIER;
  43.    private static final MethodIdentifier BOOLEAN_CONSTRUCTOR;
  44.    private static final ClassIdentifier CHARACTER_IDENTIFIER;
  45.    private static final MethodIdentifier CHARACTER_CONSTRUCTOR;
  46.    private static final ClassIdentifier INTEGER_IDENTIFIER;
  47.    private static final MethodIdentifier INTEGER_CONSTRUCTOR;
  48.    private static final ClassIdentifier LONG_IDENTIFIER;
  49.    private static final MethodIdentifier LONG_CONSTRUCTOR;
  50.    private static final ClassIdentifier FLOAT_IDENTIFIER;
  51.    private static final MethodIdentifier FLOAT_CONSTRUCTOR;
  52.    private static final ClassIdentifier DOUBLE_IDENTIFIER;
  53.    private static final MethodIdentifier DOUBLE_CONSTRUCTOR;
  54.    private static final ClassIdentifier BYTE_IDENTIFIER;
  55.    private static final MethodIdentifier BYTE_CONSTRUCTOR;
  56.    private static final ClassIdentifier SHORT_IDENTIFIER;
  57.    private static final MethodIdentifier SHORT_CONSTRUCTOR;
  58.    private static final ClassIdentifier OBJECT_IDENTIFIER;
  59.    private static final ClassIdentifier NUMBER_IDENTIFIER;
  60.    private static final MethodIdentifier BOOLEAN_BOOLEAN_VALUE_METHOD;
  61.    private static final MethodIdentifier CHARACTER_CHAR_VALUE_METHOD;
  62.    private static final MethodIdentifier NUMBER_INT_VALUE_METHOD;
  63.    private static final MethodIdentifier NUMBER_LONG_VALUE_METHOD;
  64.    private static final MethodIdentifier NUMBER_FLOAT_VALUE_METHOD;
  65.    private static final MethodIdentifier NUMBER_DOUBLE_VALUE_METHOD;
  66.    private static final MethodIdentifier NUMBER_BYTE_VALUE_METHOD;
  67.    private static final MethodIdentifier NUMBER_SHORT_VALUE_METHOD;
  68.    private String name;
  69.    private String superName;
  70.    private boolean isStaticClass;
  71.    private MethodIdentifier interpreterMethod;
  72.    private MethodIdentifier interpretArgumentsMethod;
  73.    private MethodIdentifier thrownExceptionMethod;
  74.    private String thrownExceptionName;
  75.    private InnerClassesAttribute innerClassesAttribute;
  76.    private String classLoaderId;
  77.  
  78.    public static String getMethodIdentifier(String var0, String var1, String[] var2, String var3) {
  79.       String var4 = var0 + "#" + var1 + "(";
  80.       if (var2.length > 0) {
  81.          var4 = var4 + var2[0];
  82.       }
  83.  
  84.       for(int var5 = 1; var5 < var2.length; ++var5) {
  85.          var4 = var4 + "," + var2[var5];
  86.       }
  87.  
  88.       return var4 + ")" + var3;
  89.    }
  90.  
  91.    public String createClassInitializer() {
  92.       try {
  93.          MethodInfo var1 = ((ClassFile)this).createMethod("void", "<clinit>", new String[0]);
  94.          String var2 = getMethodIdentifier(this.name, "<clinit>", new String[0], this.classLoaderId);
  95.          var1.setAccessFlags(8);
  96.          ConstantPool var3 = ((ClassFile)this).getConstantPool();
  97.          ByteArrayOutputStream var4 = new ByteArrayOutputStream();
  98.          DataOutputStream var5 = new DataOutputStream(var4);
  99.          this.bipush(0, var5);
  100.          var5.writeByte(189);
  101.          short var7 = var3.put(OBJECT_IDENTIFIER);
  102.          var5.writeShort(var7);
  103.          this.astore(0, var5);
  104.          var7 = var3.put(new ConstantString(var2));
  105.          if (var7 > 256) {
  106.             var5.writeByte(19);
  107.             var5.writeShort(var7);
  108.          } else {
  109.             var5.writeByte(18);
  110.             var5.writeByte(var7);
  111.          }
  112.  
  113.          var5.writeByte(1);
  114.          this.aload(0, var5);
  115.          var5.writeByte(184);
  116.          var5.writeShort(var3.put(this.interpreterMethod));
  117.          var5.writeByte(177);
  118.          CodeAttribute var8 = var1.createCodeAttribute();
  119.          var8.setCode(var4.toByteArray(), (short)1, (short)6);
  120.          return var2;
  121.       } catch (IOException var9) {
  122.          var9.printStackTrace();
  123.          return null;
  124.       }
  125.    }
  126.  
  127.    public String addConstructor(int var1, String[] var2, String[] var3, String var4, String[] var5) {
  128.       try {
  129.          String var6 = getMethodIdentifier(this.name, "<init>", var2, this.classLoaderId);
  130.          MethodInfo var7 = ((ClassFile)this).createMethod("void", "<init>", var2);
  131.          var7.setAccessFlags(var1);
  132.          ConstantPool var8 = ((ClassFile)this).getConstantPool();
  133.          ByteArrayOutputStream var9 = new ByteArrayOutputStream();
  134.          DataOutputStream var10 = new DataOutputStream(var9);
  135.          short var11 = 6;
  136.          short var12 = 3;
  137.  
  138.          for(int var13 = 0; var13 < var2.length; ++var13) {
  139.             String var14 = var2[var13];
  140.             if (!var14.equals("long") && !var14.equals("double")) {
  141.                ++var12;
  142.             } else {
  143.                var12 = (short)(var12 + 2);
  144.             }
  145.          }
  146.  
  147.          short var23 = var12;
  148.  
  149.          for(int var24 = 0; var24 < var5.length; ++var24) {
  150.             String var15 = var5[var24];
  151.             if (!var15.equals("long") && !var15.equals("double")) {
  152.                ++var12;
  153.                ++var11;
  154.             } else {
  155.                var12 = (short)(var12 + 2);
  156.                var11 = (short)(var11 + 2);
  157.             }
  158.          }
  159.  
  160.          this.bipush(var2.length, var10);
  161.          var10.writeByte(189);
  162.          short var25 = var8.put(OBJECT_IDENTIFIER);
  163.          var10.writeShort(var25);
  164.          if (var23 < 5) {
  165.             var10.writeByte(75 + var23 - 1);
  166.          } else {
  167.             var10.writeByte(58);
  168.             var10.writeByte(var23 - 1);
  169.          }
  170.  
  171.          int var29 = 1;
  172.  
  173.          for(int var16 = 0; var16 < var2.length; ++var16) {
  174.             String var17 = var2[var16];
  175.             this.aload(var23 - 1, var10);
  176.             this.bipush(var16, var10);
  177.             if (var17.equals("int")) {
  178.                this.loadInt(var29, var10, var8);
  179.             } else if (var17.equals("long")) {
  180.                this.loadLong(var29, var10, var8);
  181.                ++var29;
  182.             } else if (var17.equals("float")) {
  183.                this.loadFloat(var29, var10, var8);
  184.             } else if (var17.equals("double")) {
  185.                this.loadDouble(var29, var10, var8);
  186.                ++var29;
  187.             } else if (var17.equals("byte")) {
  188.                this.loadByte(var29, var10, var8);
  189.             } else if (var17.equals("short")) {
  190.                this.loadShort(var29, var10, var8);
  191.             } else if (var17.equals("boolean")) {
  192.                this.loadBoolean(var29, var10, var8);
  193.             } else if (var17.equals("char")) {
  194.                this.loadChar(var29, var10, var8);
  195.             } else {
  196.                this.aload(var29, var10);
  197.             }
  198.  
  199.             var10.writeByte(83);
  200.             ++var29;
  201.          }
  202.  
  203.          short var32 = (short)var10.size();
  204.          var25 = var8.put(new ConstantString(var6));
  205.          if (var25 > 256) {
  206.             var10.writeByte(19);
  207.             var10.writeShort(var25);
  208.          } else {
  209.             var10.writeByte(18);
  210.             var10.writeByte(var25);
  211.          }
  212.  
  213.          this.aload(var23 - 1, var10);
  214.          var10.writeByte(184);
  215.          var10.writeShort(var8.put(this.interpretArgumentsMethod));
  216.          this.astore(var23 - 2, var10);
  217.          var29 = var23;
  218.  
  219.          for(int var33 = 0; var33 < var5.length; ++var33) {
  220.             String var18 = var5[var33];
  221.             this.aload(var23 - 2, var10);
  222.             this.bipush(var33, var10);
  223.             var10.writeByte(50);
  224.             if (var18.equals("int")) {
  225.                var10.writeByte(192);
  226.                var10.writeShort(var8.put(NUMBER_IDENTIFIER));
  227.                var10.writeByte(182);
  228.                var10.writeShort(var8.put(NUMBER_INT_VALUE_METHOD));
  229.                if (var29 < 4) {
  230.                   var10.writeByte(59 + var29);
  231.                } else {
  232.                   var10.writeByte(54);
  233.                   var10.writeByte(var29);
  234.                }
  235.             } else if (var18.equals("long")) {
  236.                var10.writeByte(192);
  237.                var10.writeShort(var8.put(NUMBER_IDENTIFIER));
  238.                var10.writeByte(182);
  239.                var10.writeShort(var8.put(NUMBER_LONG_VALUE_METHOD));
  240.                if (var29 < 4) {
  241.                   var10.writeByte(63 + var29);
  242.                } else {
  243.                   var10.writeByte(55);
  244.                   var10.writeByte(var29);
  245.                }
  246.  
  247.                ++var29;
  248.             } else if (var18.equals("float")) {
  249.                var10.writeByte(192);
  250.                var10.writeShort(var8.put(NUMBER_IDENTIFIER));
  251.                var10.writeByte(182);
  252.                var10.writeShort(var8.put(NUMBER_FLOAT_VALUE_METHOD));
  253.                if (var29 < 4) {
  254.                   var10.writeByte(67 + var29);
  255.                } else {
  256.                   var10.writeByte(56);
  257.                   var10.writeByte(var29);
  258.                }
  259.             } else if (var18.equals("double")) {
  260.                var10.writeByte(192);
  261.                var10.writeShort(var8.put(NUMBER_IDENTIFIER));
  262.                var10.writeByte(182);
  263.                var10.writeShort(var8.put(NUMBER_DOUBLE_VALUE_METHOD));
  264.                if (var29 < 4) {
  265.                   var10.writeByte(71 + var29);
  266.                } else {
  267.                   var10.writeByte(57);
  268.                   var10.writeByte(var29);
  269.                }
  270.  
  271.                ++var29;
  272.             } else if (var18.equals("byte")) {
  273.                var10.writeByte(192);
  274.                var10.writeShort(var8.put(NUMBER_IDENTIFIER));
  275.                var10.writeByte(182);
  276.                var10.writeShort(var8.put(NUMBER_BYTE_VALUE_METHOD));
  277.                if (var29 < 4) {
  278.                   var10.writeByte(59 + var29);
  279.                } else {
  280.                   var10.writeByte(54);
  281.                   var10.writeByte(var29);
  282.                }
  283.             } else if (var18.equals("short")) {
  284.                var10.writeByte(192);
  285.                var10.writeShort(var8.put(NUMBER_IDENTIFIER));
  286.                var10.writeByte(182);
  287.                var10.writeShort(var8.put(NUMBER_SHORT_VALUE_METHOD));
  288.                if (var29 < 4) {
  289.                   var10.writeByte(59 + var29);
  290.                } else {
  291.                   var10.writeByte(54);
  292.                   var10.writeByte(var29);
  293.                }
  294.             } else if (var18.equals("boolean")) {
  295.                var10.writeByte(192);
  296.                var10.writeShort(var8.put(BOOLEAN_IDENTIFIER));
  297.                var10.writeByte(182);
  298.                var10.writeShort(var8.put(BOOLEAN_BOOLEAN_VALUE_METHOD));
  299.                if (var29 < 4) {
  300.                   var10.writeByte(59 + var29);
  301.                } else {
  302.                   var10.writeByte(54);
  303.                   var10.writeByte(var29);
  304.                }
  305.             } else if (var18.equals("char")) {
  306.                var10.writeByte(192);
  307.                var10.writeShort(var8.put(CHARACTER_IDENTIFIER));
  308.                var10.writeByte(182);
  309.                var10.writeShort(var8.put(CHARACTER_CHAR_VALUE_METHOD));
  310.                if (var29 < 4) {
  311.                   var10.writeByte(59 + var29);
  312.                } else {
  313.                   var10.writeByte(54);
  314.                   var10.writeByte(var29);
  315.                }
  316.             } else {
  317.                this.astore(var29, var10);
  318.             }
  319.  
  320.             ++var29;
  321.          }
  322.  
  323.          var10.writeByte(42);
  324.          var29 = var23;
  325.  
  326.          for(int var34 = 0; var34 < var5.length; ++var34) {
  327.             String var37 = var5[var34];
  328.             if (var37.equals("int")) {
  329.                this.iload(var29, var10);
  330.             } else if (var37.equals("long")) {
  331.                if (var29 < 4) {
  332.                   var10.writeByte(30 + var29);
  333.                } else {
  334.                   var10.writeByte(22);
  335.                   var10.writeByte(var29);
  336.                }
  337.  
  338.                ++var29;
  339.             } else if (var37.equals("float")) {
  340.                if (var29 < 4) {
  341.                   var10.writeByte(34 + var29);
  342.                } else {
  343.                   var10.writeByte(23);
  344.                   var10.writeByte(var29);
  345.                }
  346.             } else if (var37.equals("double")) {
  347.                if (var29 < 4) {
  348.                   var10.writeByte(38 + var29);
  349.                } else {
  350.                   var10.writeByte(24);
  351.                   var10.writeByte(var29);
  352.                }
  353.  
  354.                ++var29;
  355.             } else if (var37.equals("byte")) {
  356.                this.iload(var29, var10);
  357.             } else if (var37.equals("short")) {
  358.                this.iload(var29, var10);
  359.             } else if (var37.equals("boolean")) {
  360.                this.iload(var29, var10);
  361.             } else if (var37.equals("char")) {
  362.                this.iload(var29, var10);
  363.             } else {
  364.                this.aload(var29, var10);
  365.                var10.writeByte(192);
  366.                var10.writeShort(var8.put(new ClassIdentifier(JVMUtilities.getName(var5[var34]))));
  367.             }
  368.  
  369.             ++var29;
  370.          }
  371.  
  372.          var10.writeByte(183);
  373.  
  374.          for(int var35 = 0; var35 < var5.length; ++var35) {
  375.             var5[var35] = JVMUtilities.getParameterTypeName(var5[var35]);
  376.          }
  377.  
  378.          MethodIdentifier var36 = new MethodIdentifier(JVMUtilities.getName(var4), "<init>", JVMUtilities.getName("void"), var5);
  379.          var10.writeShort(var8.put(var36));
  380.          var25 = var8.put(new ConstantString(var6));
  381.          if (var25 > 256) {
  382.             var10.writeByte(19);
  383.             var10.writeShort(var25);
  384.          } else {
  385.             var10.writeByte(18);
  386.             var10.writeByte(var25);
  387.          }
  388.  
  389.          var10.writeByte(42);
  390.          this.aload(var23 - 1, var10);
  391.          var10.writeByte(184);
  392.          var10.writeShort(var8.put(this.interpreterMethod));
  393.          var10.writeByte(177);
  394.          short var38 = (short)var10.size();
  395.          if (var3.length > 0) {
  396.             var12 = (short)(var12 + 2);
  397.             this.astore(var12 - 2, var10);
  398.             this.aload(var12 - 2, var10);
  399.             var10.writeByte(182);
  400.             var10.writeShort(var8.put(this.thrownExceptionMethod));
  401.             this.astore(var12 - 1, var10);
  402.  
  403.             for(int var19 = 0; var19 < var3.length; ++var19) {
  404.                this.aload(var12 - 1, var10);
  405.                var10.writeByte(193);
  406.                var25 = var8.put(new ClassIdentifier(JVMUtilities.getName(var3[var19])));
  407.                var10.writeShort(var25);
  408.                var10.writeByte(153);
  409.                if (var12 < 5) {
  410.                   var10.writeShort(8);
  411.                } else {
  412.                   var10.writeShort(9);
  413.                }
  414.  
  415.                this.aload(var12 - 1, var10);
  416.                var10.writeByte(192);
  417.                var10.writeShort(var25);
  418.                var10.writeByte(191);
  419.             }
  420.  
  421.             this.aload(var12 - 2, var10);
  422.             var10.writeByte(191);
  423.          }
  424.  
  425.          CodeAttribute var39 = var7.createCodeAttribute();
  426.          var39.setCode(var9.toByteArray(), var12, var11);
  427.          if (var3.length > 0) {
  428.             var39.addExceptionTableEntry(var32, var38, var38, this.thrownExceptionName);
  429.          }
  430.  
  431.          if (var3.length > 0) {
  432.             ExceptionsAttribute var20 = var7.createExceptionsAttribute();
  433.  
  434.             for(int var21 = 0; var21 < var3.length; ++var21) {
  435.                var20.addException(var3[var21]);
  436.             }
  437.          }
  438.  
  439.          return var6;
  440.       } catch (IOException var22) {
  441.          var22.printStackTrace();
  442.          return null;
  443.       }
  444.    }
  445.  
  446.    public void addField(int var1, String var2, String var3) {
  447.       FieldInfo var4 = ((ClassFile)this).createField(var2, var3);
  448.       var4.setAccessFlags(var1);
  449.    }
  450.  
  451.    public void addConstantIntField(int var1, String var2, String var3, Integer var4) {
  452.       FieldInfo var5 = ((ClassFile)this).createField(var2, var3);
  453.       var5.setAccessFlags(var1);
  454.       var5.setConstantValueAttribute(var4);
  455.    }
  456.  
  457.    public void addConstantLongField(int var1, String var2, String var3, Long var4) {
  458.       FieldInfo var5 = ((ClassFile)this).createField(var2, var3);
  459.       var5.setAccessFlags(var1);
  460.       var5.setConstantValueAttribute(var4);
  461.    }
  462.  
  463.    public void addConstantFloatField(int var1, String var2, String var3, Float var4) {
  464.       FieldInfo var5 = ((ClassFile)this).createField(var2, var3);
  465.       var5.setAccessFlags(var1);
  466.       var5.setConstantValueAttribute(var4);
  467.    }
  468.  
  469.    public void addConstantDoubleField(int var1, String var2, String var3, Double var4) {
  470.       FieldInfo var5 = ((ClassFile)this).createField(var2, var3);
  471.       var5.setAccessFlags(var1);
  472.       var5.setConstantValueAttribute(var4);
  473.    }
  474.  
  475.    public void addConstantBooleanField(int var1, String var2, String var3, Boolean var4) {
  476.       FieldInfo var5 = ((ClassFile)this).createField(var2, var3);
  477.       var5.setAccessFlags(var1);
  478.       var5.setConstantValueAttribute(new Integer(var4 ? 1 : 0));
  479.    }
  480.  
  481.    public void addConstantStringField(int var1, String var2, String var3, String var4) {
  482.       FieldInfo var5 = ((ClassFile)this).createField(var2, var3);
  483.       var5.setAccessFlags(var1);
  484.       var5.setConstantValueAttribute(var4);
  485.    }
  486.  
  487.    public InnerClassesEntry addInnerClassesEntry() {
  488.       if (this.innerClassesAttribute == null) {
  489.          this.innerClassesAttribute = new InnerClassesAttribute(((ClassFile)this).getConstantPool());
  490.          ((ClassFile)this).setInnerClassesAttribute(this.innerClassesAttribute);
  491.       }
  492.  
  493.       return this.innerClassesAttribute.addInnerClassesEntry();
  494.    }
  495.  
  496.    public void addSuperMethodAccessor(int var1, String var2, String var3, String[] var4, String[] var5) {
  497.       try {
  498.          MethodInfo var6 = ((ClassFile)this).createMethod(var2, "super$" + var3, var4);
  499.          var6.setAccessFlags(1);
  500.          ConstantPool var7 = ((ClassFile)this).getConstantPool();
  501.          ByteArrayOutputStream var8 = new ByteArrayOutputStream();
  502.          DataOutputStream var9 = new DataOutputStream(var8);
  503.          boolean var11 = Modifier.isStatic(var1);
  504.          short var12 = (short)(var11 ? 1 : 2);
  505.  
  506.          for(int var14 = 0; var14 < var4.length; ++var14) {
  507.             String var15 = var4[var14];
  508.             if (!var15.equals("long") && !var15.equals("double")) {
  509.                ++var12;
  510.             } else {
  511.                var12 = (short)(var12 + 2);
  512.             }
  513.          }
  514.  
  515.          int var20 = 0;
  516.          if (!var11) {
  517.             var9.writeByte(42);
  518.             var20 = 1;
  519.          }
  520.  
  521.          for(int var21 = 0; var21 < var4.length; ++var21) {
  522.             String var16 = var4[var21];
  523.             if (var16.equals("int")) {
  524.                this.iload(var20, var9);
  525.             } else if (var16.equals("long")) {
  526.                if (var20 < 4) {
  527.                   var9.writeByte(30 + var20);
  528.                } else {
  529.                   var9.writeByte(22);
  530.                   var9.writeByte(var20);
  531.                }
  532.  
  533.                ++var20;
  534.             } else if (var16.equals("float")) {
  535.                if (var20 < 4) {
  536.                   var9.writeByte(34 + var20);
  537.                } else {
  538.                   var9.writeByte(23);
  539.                   var9.writeByte(var20);
  540.                }
  541.             } else if (var16.equals("double")) {
  542.                if (var20 < 4) {
  543.                   var9.writeByte(38 + var20);
  544.                } else {
  545.                   var9.writeByte(24);
  546.                   var9.writeByte(var20);
  547.                }
  548.  
  549.                ++var20;
  550.             } else if (var16.equals("byte")) {
  551.                this.iload(var20, var9);
  552.             } else if (var16.equals("short")) {
  553.                this.iload(var20, var9);
  554.             } else if (var16.equals("boolean")) {
  555.                this.iload(var20, var9);
  556.             } else if (var16.equals("char")) {
  557.                this.iload(var20, var9);
  558.             } else {
  559.                this.aload(var20, var9);
  560.                var9.writeByte(192);
  561.                var9.writeShort(var7.put(new ClassIdentifier(JVMUtilities.getName(var4[var21]))));
  562.             }
  563.  
  564.             ++var20;
  565.          }
  566.  
  567.          String[] var22 = new String[var4.length];
  568.  
  569.          for(int var23 = 0; var23 < var4.length; ++var23) {
  570.             var22[var23] = JVMUtilities.getParameterTypeName(var4[var23]);
  571.          }
  572.  
  573.          MethodIdentifier var13 = new MethodIdentifier(JVMUtilities.getName(this.superName), var3, JVMUtilities.getReturnTypeName(var2), var22);
  574.          if (var11) {
  575.             var9.writeByte(184);
  576.          } else {
  577.             var9.writeByte(183);
  578.          }
  579.  
  580.          var9.writeShort(var7.put(var13));
  581.          if (var2.equals("void")) {
  582.             var9.writeByte(177);
  583.          } else if (var2.equals("int")) {
  584.             var9.writeByte(172);
  585.          } else if (var2.equals("long")) {
  586.             var9.writeByte(173);
  587.          } else if (var2.equals("float")) {
  588.             var9.writeByte(174);
  589.          } else if (var2.equals("double")) {
  590.             var9.writeByte(175);
  591.          } else if (var2.equals("byte")) {
  592.             var9.writeByte(172);
  593.          } else if (var2.equals("short")) {
  594.             var9.writeByte(172);
  595.          } else if (var2.equals("boolean")) {
  596.             var9.writeByte(172);
  597.          } else if (var2.equals("char")) {
  598.             var9.writeByte(172);
  599.          } else {
  600.             var9.writeByte(176);
  601.          }
  602.  
  603.          CodeAttribute var24 = var6.createCodeAttribute();
  604.          var24.setCode(var8.toByteArray(), var12, var12);
  605.          if (var5.length > 0) {
  606.             ExceptionsAttribute var17 = var6.createExceptionsAttribute();
  607.  
  608.             for(int var18 = 0; var18 < var5.length; ++var18) {
  609.                var17.addException(var5[var18]);
  610.             }
  611.          }
  612.       } catch (IOException var19) {
  613.          var19.printStackTrace();
  614.       }
  615.  
  616.    }
  617.  
  618.    public String addMethod(int var1, String var2, String var3, String[] var4, String[] var5) {
  619.       try {
  620.          MethodInfo var6 = ((ClassFile)this).createMethod(var2, var3, var4);
  621.          String var7 = getMethodIdentifier(this.name, var3, var4, this.classLoaderId);
  622.          var6.setAccessFlags(var1);
  623.          if (!var6.isAbstract()) {
  624.             ConstantPool var8 = ((ClassFile)this).getConstantPool();
  625.             ByteArrayOutputStream var9 = new ByteArrayOutputStream();
  626.             DataOutputStream var10 = new DataOutputStream(var9);
  627.             byte var11 = 6;
  628.             short var12 = (short)(var6.isStatic() ? 1 : 2);
  629.  
  630.             for(int var14 = 0; var14 < var4.length; ++var14) {
  631.                String var15 = var4[var14];
  632.                if (!var15.equals("long") && !var15.equals("double")) {
  633.                   ++var12;
  634.                } else {
  635.                   var12 = (short)(var12 + 2);
  636.                }
  637.             }
  638.  
  639.             this.bipush(var4.length, var10);
  640.             var10.writeByte(189);
  641.             short var22 = var8.put(OBJECT_IDENTIFIER);
  642.             var10.writeShort(var22);
  643.             this.astore(var12 - 1, var10);
  644.             int var25 = var6.isStatic() ? 0 : 1;
  645.  
  646.             for(int var16 = 0; var16 < var4.length; ++var16) {
  647.                String var17 = var4[var16];
  648.                this.aload(var12 - 1, var10);
  649.                this.bipush(var16, var10);
  650.                if (var17.equals("int")) {
  651.                   this.loadInt(var25, var10, var8);
  652.                } else if (var17.equals("long")) {
  653.                   this.loadLong(var25, var10, var8);
  654.                   ++var25;
  655.                } else if (var17.equals("float")) {
  656.                   this.loadFloat(var25, var10, var8);
  657.                } else if (var17.equals("double")) {
  658.                   this.loadDouble(var25, var10, var8);
  659.                   ++var25;
  660.                } else if (var17.equals("byte")) {
  661.                   this.loadByte(var25, var10, var8);
  662.                } else if (var17.equals("short")) {
  663.                   this.loadShort(var25, var10, var8);
  664.                } else if (var17.equals("boolean")) {
  665.                   this.loadBoolean(var25, var10, var8);
  666.                } else if (var17.equals("char")) {
  667.                   this.loadChar(var25, var10, var8);
  668.                } else {
  669.                   this.aload(var25, var10);
  670.                }
  671.  
  672.                var10.writeByte(83);
  673.                ++var25;
  674.             }
  675.  
  676.             short var26 = (short)var10.size();
  677.             var22 = var8.put(new ConstantString(var7));
  678.             if (var22 > 256) {
  679.                var10.writeByte(19);
  680.                var10.writeShort(var22);
  681.             } else {
  682.                var10.writeByte(18);
  683.                var10.writeByte(var22);
  684.             }
  685.  
  686.             if (var6.isStatic()) {
  687.                var10.writeByte(1);
  688.             } else {
  689.                var10.writeByte(42);
  690.             }
  691.  
  692.             this.aload(var12 - 1, var10);
  693.             var10.writeByte(184);
  694.             var10.writeShort(var8.put(this.interpreterMethod));
  695.             if (var2.equals("void")) {
  696.                var10.writeByte(177);
  697.             } else if (var2.equals("int")) {
  698.                var10.writeByte(192);
  699.                var10.writeShort(var8.put(NUMBER_IDENTIFIER));
  700.                var10.writeByte(182);
  701.                var10.writeShort(var8.put(NUMBER_INT_VALUE_METHOD));
  702.                var10.writeByte(172);
  703.             } else if (var2.equals("long")) {
  704.                var10.writeByte(192);
  705.                var10.writeShort(var8.put(NUMBER_IDENTIFIER));
  706.                var10.writeByte(182);
  707.                var10.writeShort(var8.put(NUMBER_LONG_VALUE_METHOD));
  708.                var10.writeByte(173);
  709.             } else if (var2.equals("float")) {
  710.                var10.writeByte(192);
  711.                var10.writeShort(var8.put(NUMBER_IDENTIFIER));
  712.                var10.writeByte(182);
  713.                var10.writeShort(var8.put(NUMBER_FLOAT_VALUE_METHOD));
  714.                var10.writeByte(174);
  715.             } else if (var2.equals("double")) {
  716.                var10.writeByte(192);
  717.                var10.writeShort(var8.put(NUMBER_IDENTIFIER));
  718.                var10.writeByte(182);
  719.                var10.writeShort(var8.put(NUMBER_DOUBLE_VALUE_METHOD));
  720.                var10.writeByte(175);
  721.             } else if (var2.equals("byte")) {
  722.                var10.writeByte(192);
  723.                var10.writeShort(var8.put(NUMBER_IDENTIFIER));
  724.                var10.writeByte(182);
  725.                var10.writeShort(var8.put(NUMBER_BYTE_VALUE_METHOD));
  726.                var10.writeByte(172);
  727.             } else if (var2.equals("short")) {
  728.                var10.writeByte(192);
  729.                var10.writeShort(var8.put(NUMBER_IDENTIFIER));
  730.                var10.writeByte(182);
  731.                var10.writeShort(var8.put(NUMBER_SHORT_VALUE_METHOD));
  732.                var10.writeByte(172);
  733.             } else if (var2.equals("boolean")) {
  734.                var10.writeByte(192);
  735.                var10.writeShort(var8.put(BOOLEAN_IDENTIFIER));
  736.                var10.writeByte(182);
  737.                var10.writeShort(var8.put(BOOLEAN_BOOLEAN_VALUE_METHOD));
  738.                var10.writeByte(172);
  739.             } else if (var2.equals("char")) {
  740.                var10.writeByte(192);
  741.                var10.writeShort(var8.put(CHARACTER_IDENTIFIER));
  742.                var10.writeByte(182);
  743.                var10.writeShort(var8.put(CHARACTER_CHAR_VALUE_METHOD));
  744.                var10.writeByte(172);
  745.             } else {
  746.                var10.writeByte(192);
  747.                var10.writeShort(var8.put(new ClassIdentifier(JVMUtilities.getName(var2))));
  748.                var10.writeByte(176);
  749.             }
  750.  
  751.             short var27 = (short)var10.size();
  752.             if (var5.length > 0) {
  753.                var12 = (short)(var12 + 2);
  754.                this.astore(var12 - 2, var10);
  755.                this.aload(var12 - 2, var10);
  756.                var10.writeByte(182);
  757.                var10.writeShort(var8.put(this.thrownExceptionMethod));
  758.                this.astore(var12 - 1, var10);
  759.  
  760.                for(int var18 = 0; var18 < var5.length; ++var18) {
  761.                   this.aload(var12 - 1, var10);
  762.                   var10.writeByte(193);
  763.                   var22 = var8.put(new ClassIdentifier(JVMUtilities.getName(var5[var18])));
  764.                   var10.writeShort(var22);
  765.                   var10.writeByte(153);
  766.                   if (var12 < 5) {
  767.                      var10.writeShort(8);
  768.                   } else {
  769.                      var10.writeShort(9);
  770.                   }
  771.  
  772.                   this.aload(var12 - 1, var10);
  773.                   var10.writeByte(192);
  774.                   var10.writeShort(var22);
  775.                   var10.writeByte(191);
  776.                }
  777.  
  778.                this.aload(var12 - 2, var10);
  779.                var10.writeByte(191);
  780.             }
  781.  
  782.             CodeAttribute var28 = var6.createCodeAttribute();
  783.             var28.setCode(var9.toByteArray(), var12, var11);
  784.             if (var5.length > 0) {
  785.                var28.addExceptionTableEntry(var26, var27, var27, this.thrownExceptionName);
  786.             }
  787.          }
  788.  
  789.          if (var5.length > 0) {
  790.             ExceptionsAttribute var20 = var6.createExceptionsAttribute();
  791.  
  792.             for(int var21 = 0; var21 < var5.length; ++var21) {
  793.                var20.addException(var5[var21]);
  794.             }
  795.          }
  796.  
  797.          return var7;
  798.       } catch (IOException var19) {
  799.          var19.printStackTrace();
  800.          return null;
  801.       }
  802.    }
  803.  
  804.    public byte[] getByteCode() {
  805.       ByteArrayOutputStream var1 = new ByteArrayOutputStream();
  806.  
  807.       try {
  808.          ((BytecodeComponent)this).write(var1);
  809.       } catch (IOException var3) {
  810.          var3.printStackTrace();
  811.       }
  812.  
  813.       return var1.toByteArray();
  814.    }
  815.  
  816.    private void iload(int var1, DataOutputStream var2) throws IOException {
  817.       if (var1 < 4) {
  818.          var2.writeByte(26 + var1);
  819.       } else {
  820.          var2.writeByte(21);
  821.          var2.writeByte(var1);
  822.       }
  823.  
  824.    }
  825.  
  826.    private void aload(int var1, DataOutputStream var2) throws IOException {
  827.       if (var1 < 4) {
  828.          var2.writeByte(42 + var1);
  829.       } else {
  830.          var2.writeByte(25);
  831.          var2.writeByte(var1);
  832.       }
  833.  
  834.    }
  835.  
  836.    private void astore(int var1, DataOutputStream var2) throws IOException {
  837.       if (var1 < 4) {
  838.          var2.writeByte(75 + var1);
  839.       } else {
  840.          var2.writeByte(58);
  841.          var2.writeByte(var1);
  842.       }
  843.  
  844.    }
  845.  
  846.    private void bipush(int var1, DataOutputStream var2) throws IOException {
  847.       if (var1 < 6) {
  848.          var2.writeByte(3 + var1);
  849.       } else {
  850.          var2.writeByte(16);
  851.          var2.writeByte(var1);
  852.       }
  853.  
  854.    }
  855.  
  856.    private void loadInt(int var1, DataOutputStream var2, ConstantPool var3) throws IOException {
  857.       var2.writeByte(187);
  858.       var2.writeShort(var3.put(INTEGER_IDENTIFIER));
  859.       var2.writeByte(89);
  860.       if (var1 < 4) {
  861.          var2.writeByte(26 + var1);
  862.       } else {
  863.          var2.writeByte(21);
  864.          var2.writeByte(var1);
  865.       }
  866.  
  867.       var2.writeByte(183);
  868.       var2.writeShort(var3.put(INTEGER_CONSTRUCTOR));
  869.    }
  870.  
  871.    private void loadLong(int var1, DataOutputStream var2, ConstantPool var3) throws IOException {
  872.       var2.writeByte(187);
  873.       var2.writeShort(var3.put(LONG_IDENTIFIER));
  874.       var2.writeByte(89);
  875.       if (var1 < 4) {
  876.          var2.writeByte(30 + var1);
  877.       } else {
  878.          var2.writeByte(22);
  879.          var2.writeByte(var1);
  880.       }
  881.  
  882.       var2.writeByte(183);
  883.       var2.writeShort(var3.put(LONG_CONSTRUCTOR));
  884.    }
  885.  
  886.    private void loadFloat(int var1, DataOutputStream var2, ConstantPool var3) throws IOException {
  887.       var2.writeByte(187);
  888.       var2.writeShort(var3.put(FLOAT_IDENTIFIER));
  889.       var2.writeByte(89);
  890.       if (var1 < 4) {
  891.          var2.writeByte(34 + var1);
  892.       } else {
  893.          var2.writeByte(23);
  894.          var2.writeByte(var1);
  895.       }
  896.  
  897.       var2.writeByte(183);
  898.       var2.writeShort(var3.put(FLOAT_CONSTRUCTOR));
  899.    }
  900.  
  901.    private void loadDouble(int var1, DataOutputStream var2, ConstantPool var3) throws IOException {
  902.       var2.writeByte(187);
  903.       var2.writeShort(var3.put(DOUBLE_IDENTIFIER));
  904.       var2.writeByte(89);
  905.       if (var1 < 4) {
  906.          var2.writeByte(38 + var1);
  907.       } else {
  908.          var2.writeByte(24);
  909.          var2.writeByte(var1);
  910.       }
  911.  
  912.       var2.writeByte(183);
  913.       var2.writeShort(var3.put(DOUBLE_CONSTRUCTOR));
  914.    }
  915.  
  916.    private void loadByte(int var1, DataOutputStream var2, ConstantPool var3) throws IOException {
  917.       var2.writeByte(187);
  918.       var2.writeShort(var3.put(BYTE_IDENTIFIER));
  919.       var2.writeByte(89);
  920.       if (var1 < 4) {
  921.          var2.writeByte(26 + var1);
  922.       } else {
  923.          var2.writeByte(21);
  924.          var2.writeByte(var1);
  925.       }
  926.  
  927.       var2.writeByte(183);
  928.       var2.writeShort(var3.put(BYTE_CONSTRUCTOR));
  929.    }
  930.  
  931.    private void loadShort(int var1, DataOutputStream var2, ConstantPool var3) throws IOException {
  932.       var2.writeByte(187);
  933.       var2.writeShort(var3.put(SHORT_IDENTIFIER));
  934.       var2.writeByte(89);
  935.       if (var1 < 4) {
  936.          var2.writeByte(26 + var1);
  937.       } else {
  938.          var2.writeByte(21);
  939.          var2.writeByte(var1);
  940.       }
  941.  
  942.       var2.writeByte(183);
  943.       var2.writeShort(var3.put(SHORT_CONSTRUCTOR));
  944.    }
  945.  
  946.    private void loadBoolean(int var1, DataOutputStream var2, ConstantPool var3) throws IOException {
  947.       var2.writeByte(187);
  948.       var2.writeShort(var3.put(BOOLEAN_IDENTIFIER));
  949.       var2.writeByte(89);
  950.       if (var1 < 4) {
  951.          var2.writeByte(26 + var1);
  952.       } else {
  953.          var2.writeByte(21);
  954.          var2.writeByte(var1);
  955.       }
  956.  
  957.       var2.writeByte(183);
  958.       var2.writeShort(var3.put(BOOLEAN_CONSTRUCTOR));
  959.    }
  960.  
  961.    private void loadChar(int var1, DataOutputStream var2, ConstantPool var3) throws IOException {
  962.       var2.writeByte(187);
  963.       var2.writeShort(var3.put(CHARACTER_IDENTIFIER));
  964.       var2.writeByte(89);
  965.       if (var1 < 4) {
  966.          var2.writeByte(26 + var1);
  967.       } else {
  968.          var2.writeByte(21);
  969.          var2.writeByte(var1);
  970.       }
  971.  
  972.       var2.writeByte(183);
  973.       var2.writeShort(var3.put(CHARACTER_CONSTRUCTOR));
  974.    }
  975.  
  976.    public ClassFactory(int var1, String var2, String var3, Class var4, Class var5, String var6) {
  977.       super(var2, var3);
  978.       this.name = var2;
  979.       this.superName = var3;
  980.       this.classLoaderId = var6;
  981.       this.isStaticClass = (var1 & 8) != 0;
  982.       int var7 = var1 & -3 & -5 & -9;
  983.       ((AttributeOwnerComponent)this).setAccessFlags(var7 | 32 | (this.isStaticClass ? 1 : 0));
  984.       String var8 = var4.getName();
  985.       this.interpreterMethod = new MethodIdentifier(JVMUtilities.getName(var8), "invokeMethod", JVMUtilities.getReturnTypeName("java.lang.Object"), new String[]{JVMUtilities.getParameterTypeName("java.lang.String"), JVMUtilities.getParameterTypeName("java.lang.Object"), JVMUtilities.getParameterTypeName("java.lang.Object[]")});
  986.       this.interpretArgumentsMethod = new MethodIdentifier(JVMUtilities.getName(var8), "interpretArguments", JVMUtilities.getReturnTypeName("java.lang.Object[]"), new String[]{JVMUtilities.getParameterTypeName("java.lang.String"), JVMUtilities.getParameterTypeName("java.lang.Object[]")});
  987.       this.thrownExceptionName = var5.getName();
  988.       this.thrownExceptionMethod = new MethodIdentifier(JVMUtilities.getName(this.thrownExceptionName), "getException", JVMUtilities.getReturnTypeName("java.lang.Exception"), new String[0]);
  989.    }
  990.  
  991.    static {
  992.       BOOLEAN_IDENTIFIER = new ClassIdentifier(BOOLEAN_WRAPPER_NAME);
  993.       BOOLEAN_CONSTRUCTOR = new MethodIdentifier(BOOLEAN_WRAPPER_NAME, "<init>", VOID_NAME, new String[]{BOOLEAN_NAME});
  994.       CHARACTER_IDENTIFIER = new ClassIdentifier(CHAR_WRAPPER_NAME);
  995.       CHARACTER_CONSTRUCTOR = new MethodIdentifier(CHAR_WRAPPER_NAME, "<init>", VOID_NAME, new String[]{CHAR_NAME});
  996.       INTEGER_IDENTIFIER = new ClassIdentifier(INT_WRAPPER_NAME);
  997.       INTEGER_CONSTRUCTOR = new MethodIdentifier(INT_WRAPPER_NAME, "<init>", VOID_NAME, new String[]{INT_NAME});
  998.       LONG_IDENTIFIER = new ClassIdentifier(LONG_WRAPPER_NAME);
  999.       LONG_CONSTRUCTOR = new MethodIdentifier(LONG_WRAPPER_NAME, "<init>", VOID_NAME, new String[]{LONG_NAME});
  1000.       FLOAT_IDENTIFIER = new ClassIdentifier(FLOAT_WRAPPER_NAME);
  1001.       FLOAT_CONSTRUCTOR = new MethodIdentifier(FLOAT_WRAPPER_NAME, "<init>", VOID_NAME, new String[]{FLOAT_NAME});
  1002.       DOUBLE_IDENTIFIER = new ClassIdentifier(DOUBLE_WRAPPER_NAME);
  1003.       DOUBLE_CONSTRUCTOR = new MethodIdentifier(DOUBLE_WRAPPER_NAME, "<init>", VOID_NAME, new String[]{DOUBLE_NAME});
  1004.       BYTE_IDENTIFIER = new ClassIdentifier(BYTE_WRAPPER_NAME);
  1005.       BYTE_CONSTRUCTOR = new MethodIdentifier(BYTE_WRAPPER_NAME, "<init>", VOID_NAME, new String[]{BYTE_NAME});
  1006.       SHORT_IDENTIFIER = new ClassIdentifier(SHORT_WRAPPER_NAME);
  1007.       SHORT_CONSTRUCTOR = new MethodIdentifier(SHORT_WRAPPER_NAME, "<init>", VOID_NAME, new String[]{SHORT_NAME});
  1008.       OBJECT_IDENTIFIER = new ClassIdentifier(OBJECT_NAME);
  1009.       NUMBER_IDENTIFIER = new ClassIdentifier(NUMBER_NAME);
  1010.       BOOLEAN_BOOLEAN_VALUE_METHOD = new MethodIdentifier(BOOLEAN_WRAPPER_NAME, "booleanValue", BOOLEAN_NAME, new String[0]);
  1011.       CHARACTER_CHAR_VALUE_METHOD = new MethodIdentifier(CHAR_WRAPPER_NAME, "charValue", CHAR_NAME, new String[0]);
  1012.       NUMBER_INT_VALUE_METHOD = new MethodIdentifier(NUMBER_NAME, "intValue", INT_NAME, new String[0]);
  1013.       NUMBER_LONG_VALUE_METHOD = new MethodIdentifier(NUMBER_NAME, "longValue", LONG_NAME, new String[0]);
  1014.       NUMBER_FLOAT_VALUE_METHOD = new MethodIdentifier(NUMBER_NAME, "floatValue", FLOAT_NAME, new String[0]);
  1015.       NUMBER_DOUBLE_VALUE_METHOD = new MethodIdentifier(NUMBER_NAME, "doubleValue", DOUBLE_NAME, new String[0]);
  1016.       NUMBER_BYTE_VALUE_METHOD = new MethodIdentifier(NUMBER_NAME, "byteValue", BYTE_NAME, new String[0]);
  1017.       NUMBER_SHORT_VALUE_METHOD = new MethodIdentifier(NUMBER_NAME, "shortValue", SHORT_NAME, new String[0]);
  1018.    }
  1019. }
  1020.